Testing Spring Boot Clients

স্প্রিং বুট ক্লায়েন্টের টেস্টিং মূলত REST API ক্লায়েন্ট যেমন RestTemplate, WebClient, বা থার্ড-পার্টি সার্ভিসের সাথে ইন্টারঅ্যাকশন নিশ্চিত করতে ব্যবহৃত হয়। এখানে Spring Boot-এর বিভিন্ন টুল এবং টেকনিক ব্যবহার করে টেস্টিং প্রক্রিয়া ব্যাখ্যা করা হয়েছে।

১. টেস্টিং এর প্রয়োজনীয়তা

• ইনটিগ্রেশন টেস্ট: ক্লায়েন্টের সার্ভারের সাথে সংযোগ ঠিকমতো কাজ করছে কি না তা নিশ্চিত করা।
• ইউনিট টেস্ট: ক্লায়েন্ট লজিক ঠিকঠাক কাজ করছে কি না তা চেক করা।
• মকিং: নির্ভরশীল সার্ভিসগুলো মক করা, যাতে রিয়েল সার্ভিসে নির্ভরতা এড়ানো যায়।
• এন্ড-টু-এন্ড টেস্ট: সম্পূর্ণ ফ্লো পরীক্ষা করা।

২. টেস্ট ডিপেন্ডেন্সি যোগ করা

pom.xml এ নিচের ডিপেন্ডেন্সি যুক্ত করুন:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.github.tomakehurst</groupId>
    <artifactId>wiremock</artifactId>
    <scope>test</scope>
</dependency>

৩. RestTemplate এর ইউনিট টেস্ট

RestTemplate মকিং

Mockito ব্যবহার করে RestTemplate মক করা যায়।

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.web.client.RestTemplate;

public class MyServiceTest {

    @Mock
    private RestTemplate restTemplate;

    @InjectMocks
    private MyService myService;

    public MyServiceTest() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testCallExternalService() {
        // Mock API Response
        String expectedResponse = "Mock Response";
        when(restTemplate.getForObject("http://example.com/api", String.class)).thenReturn(expectedResponse);

        // Actual Call
        String actualResponse = myService.callExternalService();

        // Assertion
        assertEquals(expectedResponse, actualResponse);
    }
}

৪. WebClient এর ইউনিট টেস্ট

WebClient মকিং

WebClient টেস্ট করতে WebClient.Builder মক করা হয়।

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class MyServiceTest {

    @Mock
    private WebClient.Builder webClientBuilder;

    @Mock
    private WebClient webClient;

    @Mock
    private WebClient.RequestHeadersUriSpec<?> requestHeadersUriSpec;

    @Mock
    private WebClient.ResponseSpec responseSpec;

    @InjectMocks
    private MyService myService;

    @BeforeEach
    public void setup() {
        MockitoAnnotations.openMocks(this);
        when(webClientBuilder.build()).thenReturn(webClient);
        when(webClient.get()).thenReturn(requestHeadersUriSpec);
        when(requestHeadersUriSpec.uri("http://example.com/api")).thenReturn(requestHeadersUriSpec);
        when(requestHeadersUriSpec.retrieve()).thenReturn(responseSpec);
        when(responseSpec.bodyToMono(String.class)).thenReturn(Mono.just("Mock Response"));
    }

    @Test
    public void testCallExternalService() {
        String response = myService.callExternalService();
        assertEquals("Mock Response", response);
    }
}

৫. ইনটিগ্রেশন টেস্ট

WireMock ব্যবহার করে সার্ভার মক করা

WireMock ব্যবহার করে একটি API সার্ভার মক করা যায়।

import static com.github.tomakehurst.wiremock.client.WireMock.*;

import com.github.tomakehurst.wiremock.WireMockServer;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyServiceIntegrationTest {

    private WireMockServer wireMockServer;

    @Autowired
    private TestRestTemplate restTemplate;

    @BeforeEach
    public void setup() {
        wireMockServer = new WireMockServer(8081);
        wireMockServer.start();
        configureFor("localhost", 8081);
    }

    @AfterEach
    public void teardown() {
        wireMockServer.stop();
    }

    @Test
    public void testIntegrationWithWireMock() {
        stubFor(get(urlEqualTo("/api"))
                .willReturn(aResponse()
                        .withHeader("Content-Type", "application/json")
                        .withBody("Mock Response")));

        String response = restTemplate.getForObject("http://localhost:8081/api", String.class);
        assertEquals("Mock Response", response);
    }
}

৬. এন্ড-টু-এন্ড টেস্ট

Spring Boot এর TestRestTemplate ব্যবহার করা

TestRestTemplate ব্যবহার করে রিয়েল API কল পরীক্ষা করা যায়।

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyServiceE2ETest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testEndToEndService() {
        String response = restTemplate.getForObject("/api/external", String.class);
        assertEquals("Expected Response", response);
    }
}

৭. MockMvc ব্যবহার করে API টেস্ট

MockMvc ব্যবহার করে REST API এর টেস্ট করা হয়।

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testApiEndpoint() throws Exception {
        mockMvc.perform(get("/api/external"))
                .andExpect(status().isOk())
                .andExpect(content().string("Expected Response"));
    }
}

উপসংহার

স্প্রিং বুট ক্লায়েন্ট টেস্টিংয়ের জন্য Mockito, WireMock, এবং TestRestTemplate সহ বিভিন্ন টুল ব্যবহার করা যায়। ইউনিট, ইনটিগ্রেশন, এবং এন্ড-টু-এন্ড টেস্টিং একত্রিত করে আপনার ক্লায়েন্ট সার্ভিসের সঠিক কার্যকারিতা নিশ্চিত করতে পারেন।

Spring Boot-এ RestTemplate এবং WebClient এর জন্য Unit Testing করতে হলে আপনাকে Mocking টুল (যেমন: Mockito) ব্যবহার করতে হবে। নিচে RestTemplate এবং WebClient-এর জন্য Unit Testing-এর বিস্তারিত উদাহরণ দেওয়া হলো।

RestTemplate Unit Testing

ধাপ ১: ডিপেনডেন্সি যোগ করুন

JUnit এবং Mockito ব্যবহার করুন।

Maven Dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

ধাপ ২: RestTemplate ব্যবহার করা সার্ভিস ক্লাস

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class ApiService {

    private final RestTemplate restTemplate;

    public ApiService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String fetchData() {
        String url = "https://api.example.com/data";
        return restTemplate.getForObject(url, String.class);
    }
}

ধাপ ৩: RestTemplate এর জন্য Unit Test

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.web.client.RestTemplate;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class ApiServiceTest {

    @Mock
    private RestTemplate restTemplate;

    @InjectMocks
    private ApiService apiService;

    @Test
    public void testFetchData() {
        // Mock response
        String mockResponse = "Mocked API Response";
        String url = "https://api.example.com/data";

        // Define behavior for mock RestTemplate
        when(restTemplate.getForObject(url, String.class)).thenReturn(mockResponse);

        // Call the method
        String result = apiService.fetchData();

        // Assertions
        assertEquals(mockResponse, result);
        verify(restTemplate, times(1)).getForObject(url, String.class);
    }
}

WebClient Unit Testing

ধাপ ১: WebClient ব্যবহার করা সার্ভিস ক্লাস

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class ApiService {

    private final WebClient webClient;

    public ApiService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://api.example.com").build();
    }

    public Mono<String> fetchData() {
        return webClient.get()
                .uri("/data")
                .retrieve()
                .bodyToMono(String.class);
    }
}

ধাপ ২: WebClient এর জন্য Unit Test

WebClient-এর জন্য WebClient.Builder` Mock করা হয়।

import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.ClientResponse;
import reactor.core.publisher.Mono;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

public class ApiServiceTest {

    @Mock
    private WebClient.Builder webClientBuilder;

    @Mock
    private WebClient webClient;

    @Mock
    private WebClient.RequestHeadersUriSpec<?> requestHeadersUriSpec;

    @Mock
    private WebClient.ResponseSpec responseSpec;

    @InjectMocks
    private ApiService apiService;

    @Test
    public void testFetchData() {
        // Mock API Response
        String mockResponse = "Mocked API Response";

        // Mock WebClient behavior
        when(webClientBuilder.baseUrl("https://api.example.com")).thenReturn(webClientBuilder);
        when(webClientBuilder.build()).thenReturn(webClient);
        when(webClient.get()).thenReturn(requestHeadersUriSpec);
        when(requestHeadersUriSpec.uri("/data")).thenReturn(requestHeadersUriSpec);
        when(requestHeadersUriSpec.retrieve()).thenReturn(responseSpec);
        when(responseSpec.bodyToMono(String.class)).thenReturn(Mono.just(mockResponse));

        // Call the method
        String result = apiService.fetchData().block();

        // Assertions
        assertEquals(mockResponse, result);
        verify(webClient, times(1)).get();
        verify(requestHeadersUriSpec, times(1)).uri("/data");
    }
}

MockMVC ব্যবহার (RestTemplate বা WebClient মিলিত হলে)

Spring Boot ক্লায়েন্ট API ইন্টিগ্রেশন টেস্টের জন্য MockMVC ব্যবহার করতে পারেন।

MockMVC উদাহরণ:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class ApiControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetData() throws Exception {
        mockMvc.perform(get("/data"))
                .andExpect(status().isOk());
    }
}

সংক্ষেপে

• RestTemplate এর জন্য Mockito ব্যবহার করে getForObject, postForObject ইত্যাদি মক করা হয়।
• WebClient এর জন্য WebClient.Builder এবং সংশ্লিষ্ট মেথডগুলো Mock করতে হয়।
• Unit Testing-এর জন্য Spring Boot-এ JUnit এবং Mockito ব্যবহার করলে টেস্টিং সহজ হয়।

এভাবে আপনি RestTemplate এবং WebClient এর জন্য Unit Testing করতে পারেন।

Spring Boot ক্লায়েন্টে (Spring Boot Client) Mockito এবং MockWebServer ব্যবহার করে API টেস্টিং একটি কার্যকর পদ্ধতি। এই পদ্ধতিতে, MockWebServer ব্যবহার করে একটি কৃত্রিম সার্ভার তৈরি করা হয়, যা API রেসপন্স সিমুলেট করতে পারে। Mockito ব্যবহার করে সার্ভিস বা ডিপেন্ডেন্সি গুলো মক করা যায়।

১. প্রয়োজনীয় ডিপেন্ডেন্সি

Maven ডিপেন্ডেন্সি (pom.xml):

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>

    <!-- JUnit and Mockito -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- MockWebServer -->
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>mockwebserver</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

২. API Service

উদাহরণ সার্ভিস ক্লাস:

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ApiService {

    private final WebClient webClient;

    public ApiService(WebClient webClient) {
        this.webClient = webClient;
    }

    public String fetchData(String endpoint) {
        return webClient.get()
                .uri(endpoint)
                .retrieve()
                .bodyToMono(String.class)
                .block();
    }
}

৩. টেস্ট লিখার পদ্ধতি

Test Class:

import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import org.springframework.web.reactive.function.client.WebClient;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class ApiServiceTest {

    private MockWebServer mockWebServer;

    @InjectMocks
    private ApiService apiService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        mockWebServer = new MockWebServer();
        mockWebServer.start();
        apiService = new ApiService(WebClient.builder().baseUrl(mockWebServer.url("/").toString()).build());
    }

    @AfterEach
    void tearDown() throws Exception {
        mockWebServer.shutdown();
    }

    @Test
    void testFetchData() {
        // Mock Response
        String mockResponseBody = "{\"message\": \"Hello, World!\"}";
        mockWebServer.enqueue(new MockResponse()
                .setBody(mockResponseBody)
                .addHeader("Content-Type", "application/json"));

        // Call the method
        String response = apiService.fetchData("/test");

        // Assertions
        assertEquals(mockResponseBody, response);
    }
}

৪. কীভাবে কাজ করে

1. MockWebServer:
   • এটি একটি কৃত্রিম HTTP সার্ভার তৈরি করে।
   • রিকোয়েস্টের জন্য প্রস্তুত করা MockResponse প্রদান করে।
2. WebClient Configuration:
   • MockWebServer.url("/") ব্যবহার করে WebClient-এর বেস URL সেট করা হয়।
3. Mockito:
   • সার্ভিস বা ডিপেন্ডেন্সিগুলি মক করে টেস্টিং সহজ করা যায়।
4. JUnit Assertions:
   • টেস্টের আউটপুট যাচাই করতে JUnit assertions ব্যবহার করা হয়।

৫. আরো উদাহরণ

যদি API তে নির্দিষ্ট স্ট্যাটাস কোডের রেসপন্স পরীক্ষা করতে চান:

@Test
void testFetchDataWithErrorResponse() {
    // Mock Response with Error
    mockWebServer.enqueue(new MockResponse()
            .setResponseCode(404)
            .setBody("{\"error\": \"Not Found\"}"));

    // Call the method
    String response = apiService.fetchData("/not-found");

    // Assertions
    assertEquals(null, response); // WebClient null রিটার্ন করতে পারে।
}

৬. গুরুত্বপূর্ণ টিপস

1. কনকারেন্ট টেস্টিং:
   • MockWebServer সমান্তরাল রিকোয়েস্ট হ্যান্ডল করতে পারে।
2. Custom Headers টেস্ট:

   • MockWebServer থেকে রিকোয়েস্টের হেডার যাচাই করা যায়:

     RecordedRequest recordedRequest = mockWebServer.takeRequest();
     assertEquals("Bearer my-token", recordedRequest.getHeader("Authorization"));
     

3. Timeout Handling:

   • MockResponse এ কৃত্রিম delay যোগ করে টাইমআউট টেস্ট করতে পারেন:

     mockWebServer.enqueue(new MockResponse()
             .setBody("Delayed Response")
             .setBodyDelay(5, TimeUnit.SECONDS));
     

উপসংহার

Mockito এবং MockWebServer ব্যবহার করে Spring Boot ক্লায়েন্টের জন্য API টেস্টিং খুবই কার্যকর। এই পদ্ধতিতে:

• MockWebServer কৃত্রিম সার্ভার তৈরি করে।
• Mockito প্রয়োজনীয় ডিপেন্ডেন্সি মক করে।
• JUnit assertions ব্যবহার করে রেসপন্স যাচাই করা যায়।

যদি আপনি নির্দিষ্ট কোনো কনফিগারেশন বা টেস্টিং ইস্যু নিয়ে সাহায্য চান, জানান! 😊

স্প্রিং বুট ক্লায়েন্টে Integration Testing ব্যবহার করে API রেসপন্স যাচাই করার জন্য আপনাকে একটি সঠিক টেস্ট সেটআপ তৈরি করতে হবে। স্প্রিং বুটের জন্য @SpringBootTest, TestRestTemplate, অথবা WebTestClient ব্যবহার করে API-এর ইন্টিগ্রেশন টেস্ট করা যায়।

নিচে উদাহরণসহ Integration Testing-এর প্রক্রিয়া দেখানো হলো:

১. প্রজেক্টে টেস্ট ডিপেনডেন্সি যোগ করা

pom.xml-এ টেস্টিংয়ের জন্য নিচের ডিপেনডেন্সি যোগ করুন:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

Gradle ব্যবহার করলে:

testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.boot:spring-boot-starter-webflux'

২. TestRestTemplate ব্যবহার করে Integration Test

ক্লাস উদাহরণ

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ApiIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetApiResponse() {
        String url = "/api/resource"; // আপনার এন্ডপয়েন্ট
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);

        assertThat(response.getStatusCodeValue()).isEqualTo(200); // HTTP Status চেক
        assertThat(response.getBody()).contains("expected content"); // কনটেন্ট যাচাই
    }
}

TestRestTemplate বৈশিষ্ট্য

• সহজেই HTTP কল করতে পারে।
• API-এর জন্য সঠিক HTTP স্ট্যাটাস এবং রেসপন্স যাচাই করা যায়।
• Spring Boot Context-এর মধ্যে কাজ করে।

৩. WebTestClient ব্যবহার করে Integration Test (Reactive API এর জন্য)

ক্লাস উদাহরণ

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ReactiveApiIntegrationTest {

    private final WebTestClient webTestClient;

    public ReactiveApiIntegrationTest(WebTestClient.Builder webTestClientBuilder) {
        this.webTestClient = webTestClientBuilder
                .baseUrl("http://localhost:8080") // আপনার অ্যাপের বেস URL
                .build();
    }

    @Test
    public void testGetApiResponse() {
        webTestClient.get()
                .uri("/api/resource")
                .exchange()
                .expectStatus().isOk() // HTTP Status যাচাই
                .expectBody()
                .jsonPath("$.key").isEqualTo("expectedValue"); // JSON ফিল্ড যাচাই
    }
}

WebTestClient বৈশিষ্ট্য

• Reactive API টেস্টের জন্য উপযোগী।
• JSON রেসপন্স বা নির্দিষ্ট ফিল্ড চেক করার জন্য সহজ JSONPath সাপোর্ট।

৪. Mocking External APIs Using WireMock

WireMock ব্যবহার করে বাইরের API গুলোর জন্য সিমুলেটেড রেসপন্স তৈরি করা যায়।

WireMock Dependency

<dependency>
    <groupId>com.github.tomakehurst</groupId>
    <artifactId>wiremock</artifactId>
    <scope>test</scope>
</dependency>

WireMock Integration Example

import com.github.tomakehurst.wiremock.client.WireMock;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.web.reactive.function.client.WebClient;

import static com.github.tomakehurst.wiremock.client.WireMock.*;

@SpringBootTest
public class WireMockIntegrationTest {

    private WireMockServer wireMockServer;

    @Autowired
    private WebClient.Builder webClientBuilder;

    @BeforeEach
    public void setup() {
        wireMockServer = new WireMockServer(8089); // WireMock Server এর পোর্ট
        wireMockServer.start();
        WireMock.configureFor("localhost", 8089);
    }

    @AfterEach
    public void teardown() {
        wireMockServer.stop();
    }

    @Test
    public void testExternalApiCall() {
        // Mock API Response
        stubFor(get(urlEqualTo("/external-api"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody("{\"message\": \"success\"}")));

        // Call API
        WebClient webClient = webClientBuilder.baseUrl("http://localhost:8089").build();
        String response = webClient.get()
                .uri("/external-api")
                .retrieve()
                .bodyToMono(String.class)
                .block();

        // Assertion
        assertThat(response).contains("success");
    }
}

৫. টেস্ট রেসাল্ট যাচাই

টেস্ট চালানোর সময়:

• @SpringBootTest অ্যাপ্লিকেশনের পুরো প্রসঙ্গ লোড করে।
• Mocked APIs প্রকৃত API-এর বিকল্প হিসেবে কাজ করে।
• JSONPath বা স্ট্যাটাস চেক ব্যবহার করে রেসপন্স যাচাই করা হয়।

Run Test

mvn test
# বা
gradle test

সারাংশ

1. TestRestTemplate: সিম্পল HTTP API ইন্টিগ্রেশন টেস্টের জন্য।
2. WebTestClient: Reactive API টেস্টের জন্য।
3. WireMock: বাইরের API-র জন্য Mock করা রেসপন্স।

উপরের উদাহরণগুলোর মাধ্যমে স্প্রিং বুট ক্লায়েন্টের জন্য সহজেই Integration Testing সেটআপ এবং API রেসপন্স যাচাই করতে পারবেন।

স্প্রিং বুট ক্লায়েন্টের টেস্টিং করতে হলে সাধারণত আপনি REST API কলগুলোর সঠিক কার্যকারিতা এবং ফলাফল নিশ্চিত করতে MockWebServer, MockRestServiceServer, অথবা WebClient-এর টেস্টিং ফ্রেমওয়ার্ক ব্যবহার করবেন।

১. MockWebServer ব্যবহার করে টেস্টিং

MockWebServer হলো একটি টুল যা API কলগুলিকে মক করার জন্য ব্যবহৃত হয়। এটি সহজেই HTTP সার্ভার সিমুলেট করতে পারে।

Maven ডিপেন্ডেন্সি

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>mockwebserver</artifactId>
    <scope>test</scope>
</dependency>

পর্যায়ক্রমিক ধাপ:

Step 1: WebClient কনফিগার করা

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder.build();
    }
}

Step 2: সার্ভিস ক্লাস তৈরি

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ApiService {

    @Autowired
    private WebClient webClient;

    public String getApiResponse(String url) {
        return webClient.get()
                .uri(url)
                .retrieve()
                .bodyToMono(String.class)
                .block(); // For synchronous testing
    }
}

Step 3: টেস্ট কেস লেখা

import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class ApiServiceTest {

    @Autowired
    private ApiService apiService;

    private MockWebServer mockWebServer;

    @BeforeEach
    void setUp() throws Exception {
        mockWebServer = new MockWebServer();
        mockWebServer.start();
    }

    @AfterEach
    void tearDown() throws Exception {
        mockWebServer.shutdown();
    }

    @Test
    void testGetApiResponse() {
        // Mock response
        mockWebServer.enqueue(new MockResponse()
                .setBody("{\"message\":\"Hello, World!\"}")
                .addHeader("Content-Type", "application/json"));

        String baseUrl = mockWebServer.url("/").toString();
        String response = apiService.getApiResponse(baseUrl);

        // Assertion
        assertEquals("{\"message\":\"Hello, World!\"}", response);
    }
}

২. MockRestServiceServer ব্যবহার করে টেস্টিং

MockRestServiceServer হল Spring Framework-এর একটি টুল, যা RestTemplate টেস্ট করতে ব্যবহৃত হয়।

Step 1: RestTemplate কনফিগার

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Step 2: সার্ভিস ক্লাস তৈরি

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public String getApiResponse(String url) {
        return restTemplate.getForObject(url, String.class);
    }
}

Step 3: টেস্ট কেস লেখা

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;

import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class RestTemplateServiceTest {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private RestTemplateService restTemplateService;

    private MockRestServiceServer mockServer;

    @BeforeEach
    void setUp() {
        mockServer = MockRestServiceServer.createServer(restTemplate);
    }

    @Test
    void testGetApiResponse() {
        // Mock response
        String mockResponse = "{\"message\":\"Hello, RestTemplate!\"}";
        mockServer.expect(requestTo("http://mock-api.com"))
                .andRespond(withSuccess(mockResponse, org.springframework.http.MediaType.APPLICATION_JSON));

        String response = restTemplateService.getApiResponse("http://mock-api.com");

        // Assertion
        assertEquals("{\"message\":\"Hello, RestTemplate!\"}", response);
    }
}

৩. WebTestClient ব্যবহার করে টেস্টিং

WebTestClient একটি রিয়াক্টিভ টেস্ট টুল, যা WebClient-সহ অন্যান্য রিয়াক্টিভ স্ট্যাক টেস্ট করার জন্য ব্যবহৃত হয়।

Step 1: টেস্ট ক্লাসে WebTestClient Bean যোগ করা

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebClientIntegrationTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void testGetApi() {
        webTestClient.get().uri("/api/endpoint")
                .exchange()
                .expectStatus().isOk()
                .expectBody(String.class)
                .isEqualTo("{\"message\":\"Hello, WebClient!\"}");
    }
}

উপসংহার

• MockWebServer: WebClient বা যেকোনো HTTP ক্লায়েন্ট টেস্ট করার জন্য।
• MockRestServiceServer: RestTemplate টেস্ট করার জন্য।
• WebTestClient: রিয়াক্টিভ স্ট্যাক বা WebClient টেস্ট করার জন্য।

এই পদ্ধতিগুলি ব্যবহার করে আপনি স্প্রিং বুট ক্লায়েন্টের কার্যকারিতা নির্ভরযোগ্যভাবে টেস্ট করতে পারবেন।